Bandit Security Linting: Identifisering og redusering av Python sikkerhetssårbarheter

I dagens komplekse cybersikkerhetslandskap er proaktive sikkerhetstiltak avgjørende. Python, kjent for sin allsidighet og brukervennlighet, er et populært valg for ulike applikasjoner. Men, som alle programmeringsspråk, kan Python-kode være utsatt for sikkerhetssårbarheter. Dette er der Bandit kommer inn – et kraftig sikkerhetsverktøy designet for automatisk å identifisere potensielle sikkerhetsfeil i Python-koden din.

Hva er Bandit?

Bandit er en åpen kildekode sikkerhetslinter spesielt designet for Python. Den fungerer ved å skanne Python-kode for vanlige sikkerhetsproblemer, ved å bruke et omfattende sett med plugins for å identifisere potensielle sårbarheter. Tenk på det som et statisk analyseverktøy som hjelper deg å fange sikkerhetsproblemer tidlig i utviklingssyklusen, før de kan utnyttes i produksjon.

Bandit opererer ved å analysere Python-kode og bygge et Abstract Syntax Tree (AST). Deretter bruker den en rekke tester, basert på kjente sårbarhetsmønstre, på AST-en. Når et potensielt sikkerhetsproblem er funnet, rapporterer Bandit det med et alvorlighetsnivå, konfidensnivå og en detaljert beskrivelse av problemet.

Hvorfor bruke Bandit?

Å integrere Bandit i utviklingsarbeidsflyten din tilbyr flere betydelige fordeler:

• Tidlig sårbarhetsdeteksjon: Bandit hjelper deg med å identifisere sikkerhetssårbarheter tidlig i utviklingsprosessen, noe som reduserer kostnadene og innsatsen som kreves for å fikse dem senere.
• Forbedret kodekvalitet: Ved å håndheve sikker kodepraksis, bidrar Bandit til generell kodekvalitet og vedlikeholdbarhet.
• Automatiserte sikkerhetsrevisjoner: Bandit automatiserer prosessen med sikkerhetsrevisjon, noe som gjør det enklere å sikre at koden din overholder sikkerhetsbestemmelser.
• OWASP Top 10 dekning: Bandit inkluderer tester som tar for seg mange av sårbarhetene som er oppført i OWASP Top 10, og hjelper deg med å beskytte mot vanlige sikkerhetsrisikoer for webapplikasjoner.
• Tilpassbare regler: Du kan tilpasse Bandits regler for å passe dine spesifikke sikkerhetskrav og kodestandarder.
• Integrasjon med CI/CD-pipelines: Bandit kan enkelt integreres i dine Continuous Integration/Continuous Deployment (CI/CD)-pipelines, og sikrer at sikkerhetssjekker utføres automatisk ved hver kodeendring.

Komme i gang med Bandit

Her er en trinnvis guide for å komme i gang med Bandit:

1. Installasjon

Du kan installere Bandit ved hjelp av pip, Python-pakkeinstallasjonsprogrammet:

            pip install bandit
            

              
                Copy
              
            
          

2. Kjøre Bandit

For å kjøre Bandit på Python-koden din, bruk følgende kommando:

            bandit -r 
            

              
                Copy
              
            
          

Erstatt <directory> med katalogen som inneholder Python-koden din. -r-flagget forteller Bandit å rekursivt skanne alle Python-filer i den spesifiserte katalogen.

Du kan også spesifisere individuelle filer:

            bandit  
            

              
                Copy
              
            
          

3. Tolke resultatene

Bandit vil gi en rapport som beskriver eventuelle potensielle sikkerhetssårbarheter som er funnet i koden din. Hver sårbarhet er tildelt et alvorlighetsnivå (f.eks. HØY, MEDIUM, LAV) og et konfidensnivå (f.eks. HØY, MEDIUM, LAV). Rapporten inkluderer også en detaljert beskrivelse av sårbarheten og kodelinjen der den ble funnet.

Eksempel på Bandit-utdata:

            ./example.py:10:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:10
--------------------------------------------------

            

              
                Copy
              
            
          

Denne utdataen indikerer at Bandit fant en sårbarhet med høy alvorlighetsgrad i filen example.py på linje 10. Sårbarheten er relatert til bruken av subprocess.Popen med shell=True, som er kjent for å være utsatt for shell injection-angrep.

Vanlige sikkerhetssårbarheter oppdaget av Bandit

Bandit kan oppdage et bredt spekter av vanlige sikkerhetssårbarheter i Python-kode. Her er noen eksempler:

• Shell Injection (B602, B603): Bruk av subprocess.Popen eller os.system med utrovert input kan føre til shell injection-angrep.
• SQL Injection (B608): Å konstruere SQL-spørsmål ved hjelp av strengsammenkobling med brukerleverte data kan utsette applikasjonen din for SQL injection-angrep.
• Hardkodede passord (B105): Å lagre passord direkte i koden din er en stor sikkerhetsrisiko.
• Svak kryptografi (B303, B304, B322): Å bruke svake eller utdaterte kryptografiske algoritmer kan kompromittere konfidensialiteten og integriteten til dataene dine.
• Usikker deserialisering (B301, B401): Å deserialisere data fra utrovert kilde kan føre til vilkårlig kodekjøring.
• XML External Entity (XXE) Injection (B405): Å analysere XML-dokumenter fra utrovert kilde uten riktig sanering kan utsette applikasjonen din for XXE injection-angrep.
• Format String-sårbarheter (B323): Å bruke brukerleverte data i formatstrenger uten riktig sanering kan føre til format string-sårbarheter.
• Bruke `eval()` eller `exec()` (B301): Disse funksjonene utfører vilkårlig kode, og å bruke dem med utrovert input er ekstremt farlig.
• Usikker bruk av midlertidige filer (B308): Å opprette midlertidige filer på en forutsigbar plassering kan tillate angripere å overskrive eller lese sensitive data.
• Manglende eller feil feilhåndtering (B110): Å ikke håndtere unntak riktig kan avsløre sensitiv informasjon eller føre til tjenestenektangrep.

Eksempel: Identifisering og fiksing av en Shell Injection-sårbarhet

La oss se på et enkelt eksempel på hvordan Bandit kan hjelpe deg med å identifisere og fikse en shell injection-sårbarhet.

Vurder følgende Python-kode:

            import subprocess
import os

def execute_command(command):
    subprocess.Popen(command, shell=True)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

Denne koden tar brukerinput og utfører den som en shell-kommando ved hjelp av subprocess.Popen med shell=True. Dette er et klassisk eksempel på en shell injection-sårbarhet.

Å kjøre Bandit på denne koden vil gi følgende utdata:

            ./example.py:4:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:4
--------------------------------------------------

            

              
                Copy
              
            
          

Bandit identifiserer riktig bruken av subprocess.Popen med shell=True som en sårbarhet med høy alvorlighetsgrad.

For å fikse denne sårbarheten bør du unngå å bruke shell=True og i stedet sende kommandoen og argumentene som en liste til subprocess.Popen. Du bør også sanere brukerinputen for å forhindre at ondsinnede kommandoer blir injisert.

Her er en korrigert versjon av koden:

            import subprocess
import shlex

def execute_command(command):
    # Sanitize the input using shlex.split to prevent shell injection
    command_list = shlex.split(command)
    subprocess.Popen(command_list)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

Ved å bruke shlex.split for å sanere brukerinputen og sende kommandoen som en liste til subprocess.Popen, kan du redusere risikoen for shell injection-angrep.

Å kjøre Bandit på den korrigerte koden vil ikke lenger rapportere shell injection-sårbarheten.

Konfigurere Bandit

Bandit kan konfigureres ved hjelp av en konfigurasjonsfil (bandit.yaml eller .bandit) for å tilpasse oppførselen. Du kan bruke konfigurasjonsfilen til:

• Ekskludere filer eller kataloger: Spesifiser filer eller kataloger som skal ekskluderes fra skanningen.
• Deaktivere spesifikke tester: Deaktiver tester som ikke er relevante for prosjektet ditt.
• Justere alvorlighetsnivåer: Endre alvorlighetsnivåene for spesifikke sårbarheter.
• Definere egendefinerte regler: Lag dine egne egendefinerte regler for å oppdage prosjektspesifikke sikkerhetsproblemer.

Her er et eksempel på en bandit.yaml konfigurasjonsfil:

            exclude:
  - 'tests/'
  - 'docs/'

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

Denne konfigurasjonsfilen ekskluderer tests/- og docs/-katalogene fra skanningen, hopper over B101-testen (som sjekker bruken av påstander), justerer konfidensnivået for B603-testen til MEDIUM, og justerer alvorlighetsnivået for B105-testen til LAV.

Integrere Bandit i din CI/CD-pipeline

Å integrere Bandit i din CI/CD-pipeline er et avgjørende skritt for å sikre sikkerheten til Python-koden din. Ved å kjøre Bandit automatisk ved hver kodeendring, kan du fange sikkerhetssårbarheter tidlig og forhindre at de når produksjon.

Her er et eksempel på hvordan du integrerer Bandit i en GitLab CI/CD-pipeline:

            stages:
  - test

bandit:
  image: python:3.9
  stage: test
  before_script:
    - pip install bandit
  script:
    - bandit -r .
  artifacts:
    reports:
      bandit: bandit.report

            

              
                Copy
              
            
          

Denne konfigurasjonen definerer en bandit-jobb som kjører Bandit på gjeldende katalog. Jobben bruker et Python 3.9 Docker-bilde og installerer Bandit ved hjelp av pip. Kommandoen bandit -r . kjører Bandit rekursivt på alle Python-filer i gjeldende katalog. artifacts-delen spesifiserer at Bandit-rapporten skal lagres som en artefakt, som kan lastes ned og gjennomgås.

Lignende konfigurasjoner kan opprettes for andre CI/CD-plattformer, for eksempel Jenkins, CircleCI og GitHub Actions.

Utover Bandit: Omfattende sikkerhetsstrategier

Mens Bandit er et verdifullt verktøy for å identifisere potensielle sikkerhetssårbarheter, er det viktig å huske at det bare er én del av en omfattende sikkerhetsstrategi. Andre viktige sikkerhetsmetoder inkluderer:

• Sikker kodepraksis: Følg sikre kodingsretningslinjer og beste praksis for å minimere risikoen for å introdusere sårbarheter i koden din.
• Regelmessige sikkerhetsrevisjoner: Utfør regelmessige sikkerhetsrevisjoner for å identifisere og løse potensielle sikkerhetssvakheter i applikasjonen din.
• Penetrasjonstesting: Utfør penetrasjonstesting for å simulere angrep i den virkelige verden og identifisere sårbarheter som kanskje ikke blir oppdaget av statiske analyseverktøy som Bandit.
• Sårbarhetsstyring: Implementer et program for sårbarhetsstyring for å spore og utbedre sårbarheter i programvaren og infrastrukturen din.
• Avhengighetsstyring: Hold avhengighetene dine oppdatert for å reparere kjente sårbarheter i tredjepartsbiblioteker. Verktøy som `pip-audit` og `safety` kan hjelpe med dette.
• Validering og sanering av input: Valider og saner alltid brukerinput for å forhindre injeksjonsangrep og andre input-relaterte sårbarheter.
• Autentisering og autorisasjon: Implementer sterke autentiserings- og autorisasjonsmekanismer for å beskytte sensitive data og ressurser.
• Sikkerhetsbevissthetstrening: Gi sikkerhetsbevissthetstrening til utviklerne dine og andre ansatte for å utdanne dem om vanlige sikkerhetstrusler og beste praksis.

Konklusjon

Bandit er et verdifullt verktøy for å identifisere og redusere sikkerhetssårbarheter i Python-kode. Ved å integrere Bandit i din utviklingsarbeidsflyt, kan du forbedre sikkerheten til applikasjonene dine og beskytte mot vanlige sikkerhetstrusler. Det er imidlertid viktig å huske at Bandit bare er én del av en omfattende sikkerhetsstrategi. Ved å følge sikker kodepraksis, utføre regelmessige sikkerhetsrevisjoner og implementere andre sikkerhetstiltak, kan du skape et tryggere og mer motstandsdyktig programmiljø.

Ressurser

• Bandit-dokumentasjon
• OWASP (Open Web Application Security Project)
• Bandit på PyPI